/**
 * 標籤面板插件
 * @author Ly
 * @version 1.0a
 */
/**
 * 標籤面板插件構造函數
 * @param {Object} config 標籤面板插件配置參數
 * config = {
	 container : document.body,      // 標籤面板容器，面板的寬高都取決于此容器
	 items     : [],                 // 標籤項配置參數，參見單個標籤項配置參數列表
	 events    : {}                  // 標籤的公共事件
 }
 */
Ly.RRTabPanel = function(config /* Object */) {
	var _this = this;
	
	config = config || {};
	
	this.handler = {
		panel             : null,       // 標籤面板對象
		tabsBar           : null,       // 標籤欄
		tabsBlock         : null,       // 可視的標籤塊。
		tabsContainer     : null,       // 標籤容器，用于多標籤的滾動
		leftScrollButton  : null,       // 向左滾動標籤按鈕
		rightScrollButton : null,       // 向右滾動標籤按鈕
		workarea          : null,       // 工作區
		cache             : [],         // 標籤對象緩存
		tabs              : [],         // 創建后的標籤對象相關信息
		activedTab        : null,       // 當前已激活的標籤
		
		// 系統事件，綁定到每個標籤
		systemEvents      : {
//			onmouseover : function(obj, event) {
//				var nodes = this.childNodes;
//				
//				for (var i = 0, len = nodes.length; i < len; ++i) {
//					if (nodes[i].className.indexOf('-active') > -1) { continue; }
//					nodes[i].className += ' ly-rrtabpanel-' + nodes[i].getAttribute('role').toLowerCase() + '-active';
//				}
//			},
//			onmouseout  : function(obj, event) {
//				var nodes = this.childNodes;
//				
//				event = event || window.event;
//				
//				if (_this.handler.activedTab === this) { return; };
//				if (this.contains && this.contains(event.toElement)) {
//					return;
//				} else if (Ly.owner(this, event.relatedTarget)) {
//					return;
//				}
//				
//				for (var i = 0, len = nodes.length; i < len; ++i) {
//					nodes[i].className = nodes[i].className.replace(' ly-rrtabpanel-' + nodes[i].getAttribute('role').toLowerCase() + '-active', '');
//				}
//			},
			onclick : function() { _this.method.toggle(this); }
		},
		
		// 關閉按鈕事件，綁定到標籤的關閉按鈕上
		closeButtonEvents : {
			onmouseover : function(obj, event) {
				this.className += ' ly-rrtabpanel-closebutton-active';
			},
			onmouseout : function(obj, event) {
				this.className = this.className.replace(' ly-rrtabpanel-closebutton-active', '');
			},
			onclick : function() {
				_this.method.closeTab(this.parentNode.parentNode);
			}
		},
		
		// 標籤滾動按鈕事件
		scrollButtonEvents : {
			onmousedown : function(obj, event) {
				var scrollParams = _this.config.scrollParams,
					direction    = this.getAttribute('role').toLowerCase() === 'leftscrollbutton' ? -1 * scrollParams.speed : scrollParams.speed;
				
				_this.method.slidingTabsBar(direction);
				scrollParams.timer = setInterval(function() { _this.method.slidingTabsBar(direction); }, scrollParams.delay);
			},
			onmouseup   : function(obj, event) {
				clearInterval(_this.config.scrollParams.timer);
			}
		}
	};
	this.config = {
		container         : config.container || document.body,      // 標籤面板容器
		
		// 下麵大寫的常量修改時要對照CSS樣式表。
		TABHEIGHT         : 28,                                     // 標籤的高度
		TABPADDING        : 10,                                      // 標籤文件兩邊的留白
		SCROLLBUTTONWIDTH : 15,                                     // 滾動塊按鈕的寬度
		SCROLLBUTTONALPHA : .3,                                     // 滾動塊禁用時的透明度
		CLOSEBUTTONWIDTH  : 15,                                     // 標籤的關閉按鈕寬度
		TABMARGINLEFT     : 5,                                      // 兩個標籤之間的間隔大小
		
		tabsWidth         : 0,                                      // 所有標籤的實際寬度
		scrollParams      : {                                       // 滾動標籤時的參數
			speed : 5,                                              // 標籤滾動的速度
			delay : 25,                                             // 標籤動畫的間隔
			timer : null                                            // 動畫的時間句柄
		},
		events            : config.events || {}                     // 標籤的公共事件
	};
	this.method = {
		/**
		 * 獲取標籤對象相關信息
		 * @param {Object} tab 標籤對象
		 * @return {Object} 當前標籤的相關信息對象，並且包含一個新的屬性，標識在陣列中的索引
		 */
		getTabInfo : function(tab /* Object */) {
			var tabs = _this.handler.tabs;
			
			for (var i = 0, len = tabs.length; i < len; ++i) {
				if (tabs[i].tab === tab) {
					tabs[i].tmpIndex = i;
					return tabs[i];
				}
			}
			
			return null;
		},
		
		/**
		 * 获取标签的宽度
		 * @param {Object} tab 參照標籤
		 * @param {Boolean} flag 是否包含此標籤，默認false
		 */
		getTabsWidth : function(tab /* Object */, flag /* Boolean */) {
			var handler = _this.handler,
				config  = _this.config,
				tabs    = handler.tabs,
				width   = 0;
			
			for (var i = 0, len = tabs.length; i < len; ++i) {
				if (arguments.length == 0) {
					width += config.TABMARGINLEFT + (tabs[i].tab ? tabs[i].tab.clientWidth : 0);
				} else {
					if (tabs[i].tab === tab) {
						if (flag) {
							width += config.TABMARGINLEFT + tabs[i].tab.clientWidth;
						}
						break;
					}
					width += config.TABMARGINLEFT + tabs[i].tab.clientWidth;
				}
			}
			
			return width;
		},
		
		/**
		 * 格式化數據
		 * @param {Object} item 要格式化的數據
		 */
		formattingData : function(item /* Object */) {
			return {
				title              : item.title || '',
				width              : item.width > 0 ? item.width : 0,
				style              : item.style || '',
				loadPage           : item.loadPage || '',
				preload            : !!item.preload,
				reload             : !!item.reload,
				defaultTab         : !!item.defaultTab,
				closeButton        : !!item.closeButton,
				closeButtonHandler : item.closeButtonHandler || null,
				events             : item.events || {}
			};
		},
		
		// 創建插件的主體
		createFrame : function() {
			var handler = _this.handler,
				config  = _this.config;
			
			handler.panel = Ly.createElement('div', {
				cls : 'ly-rrtabpanel-panel'
			});
			handler.tabsBar = Ly.createElement('div', {
				cls : 'ly-rrtabpanel-tabsbar'
			});
			handler.tabsBlock = Ly.createElement('div', {
				cls : 'ly-rrtabpanel-tabsblock'
			});
			handler.tabsContainer = Ly.createElement('div', {
				cls : 'ly-rrtabpanel-tabscontainer'
			});
			handler.leftScrollButton = Ly.createElement('span', {
				cls  : 'ly-rrtabpanel-leftscrollbutton',
				role : 'leftScrollButton'
			});
			handler.rightScrollButton = Ly.createElement('span', {
				cls  : 'ly-rrtabpanel-rightscrollbutton',
				role : 'rightScrollButton'
			});
			handler.workarea = Ly.createElement('div', {
				cls : 'ly-rrtabpanel-workarea'
			});
			
			handler.tabsBlock.appendChild(handler.tabsContainer);
			handler.tabsBar.appendChild(handler.leftScrollButton);
			handler.tabsBar.appendChild(handler.tabsBlock);
			handler.tabsBar.appendChild(handler.rightScrollButton);
			handler.panel.appendChild(handler.tabsBar);
			handler.panel.appendChild(handler.workarea);
			
			config.container.appendChild(handler.panel);
			
			this.bindScrollButtonEvents();
			
			return this;
		},
		
		/**
		 * 創建標籤
		 * @param {Object} item 標籤配置信息
		 */
		createTab : function(item /* Object */) {
			var handler = _this.handler,
				config  = _this.config,
				tabs    = handler.tabs,
				tab     = {
					tab     : Ly.createElement('div', {
						cls : 'ly-rrtabpanel-tab',
						role : 'tab'
					}),
					tabNode : Ly.createElement('div', {
						cls       : 'ly-rrtabpanel-tabnode',
						style     : item.style,
						role      : 'tabNode',
						innerHTML : item.title
					}),
					closeButton : Ly.createElement('span', {
						cls : 'ly-rrtabpanel-closebutton',
						role : 'closeButton'
					}),
					tabLeft : Ly.createElement('span', {
						cls : 'ly-rrtabpanel-tableft',
						role : 'tabLeft'
					}),
					tabRight : Ly.createElement('span', {
						cls : 'ly-rrtabpanel-tabright',
						role : 'tabRight'
					}),
					workarea : Ly.createElement('iframe', {
						cls : 'ly-rrtabpanel-iframe',
						frameBorder : 0,
						style : 'height:' + handler.workarea.clientHeight + 'px;',
						src : item.preload ? item.loadPage : Ly.getPath() + 'blank.html'
					}),
					item     : item
				};
			
			tab.tabNode.appendChild(tab.closeButton);
			tab.tab.appendChild(tab.tabLeft);
			tab.tab.appendChild(tab.tabNode);
			tab.tab.appendChild(tab.tabRight);
			handler.tabsContainer.appendChild(tab.tab);
			
			handler.workarea.appendChild(tab.workarea);
			
			tabs.push(tab);
			
			this.setTabSize(tab).bindTabEvents(tab);
			
			if (item.defaultTab) {
				this.toggle(tab.tab).sliding(tab.tab);
			}
			
			return this;
		},
		
		// 載入所有的標籤
		loadTabs : function() {
			var handler    = _this.handler,
				config     = _this.config;
			
			for (var i = 0, len = handler.cache.length; i < len; ++i) {
				this.createTab(handler.cache[i]);
			}
			
			this.clearCache();
			
			!handler.activedTab && handler.tabs.length && this.toggle(handler.tabs[0].tab).updateTabsView();
			
			return this;
		},
		
		// 設置插件框架中各容器的大小
		setPanelSize : function() {
			var handler = _this.handler,
				tabs    = handler.tabs,
				config  = _this.config,
				width   = config.container.clientWidth,
				height  = config.container.clientHeight,
				scrollButtonsWidth = config.SCROLLBUTTONWIDTH * 2;
			
			handler.panel.style.width     = width + 'px';
			handler.panel.style.height    = height + 'px';
			handler.tabsBar.style.width   = width + 'px';
			handler.workarea.style.width  = width + 'px';
			handler.tabsBlock.style.width = (width - scrollButtonsWidth) + 'px';
			
			var w = handler.workarea.style.width  = (width - 2 /* border-left-width + border-right-width */) + 'px';
			var h = handler.workarea.style.height = (height - config.TABHEIGHT - 4 /* border-top-width */ - 1 /* border-bottom-width */) + 'px';
			
			for (var i = 0, len = tabs.length; i < len; ++i) {
				tabs[i].workarea.style.width = w;
				tabs[i].workarea.style.height = h;
			}
			return this;
		},
		
		/**
		 * 設置標籤的大小
		 * @param {Object} tab 標籤對象，包含標籤節點，關閉按鈕，左右圓角對象，相關配置信息
		 */
		setTabSize : function(tab /* Object */) {
			var handler = _this.handler,
				config  = _this.config,
				item    = tab.item;
			
			if (item.width) {
				tab.tabNode.style.width = (item.width - 5 * 2 /* tableft + tabright */ - config.TABPADDING * 2 - (item.closeButton ? config.CLOSEBUTTONWIDTH : 0)) + 'px';
			}
			if (item.closeButton) {
				tab.tabNode.style.paddingRight    = (config.CLOSEBUTTONWIDTH + config.TABPADDING) + 'px';
				tab.tabNode.style.display         = 'block';
				tab.closeButton.style.display     = 'block';
			}
			
			return this;
		},
		
		// 更新标签栏视图
		updateTabsView : function() {
			_this.config.tabsWidth = this.getTabsWidth();
			this.toggleScrollButtons(_this.config.tabsWidth > _this.handler.tabsBlock.clientWidth).updateScrollButtonStyle();
			
			return this;
		},
		
		// 更新滚动按钮的样式
		updateScrollButtonStyle : function() {
			var handler = _this.handler,
				config  = _this.config,
				tabsBlock = handler.tabsBlock,
				setStyle = function(obj, opacity) {
					obj.style.opacity = opacity;
					obj.style.filter  = 'Alpha(opacity=' + (opacity * 100) + ')';
					obj.style.cursor = opacity == 1 ? 'pointer' : 'default';
					return arguments.callee;
				};
			
			if (tabsBlock.scrollLeft == 0) {
				setStyle(handler.leftScrollButton, config.SCROLLBUTTONALPHA)(handler.rightScrollButton, 1);
			} else  if (tabsBlock.scrollLeft + tabsBlock.clientWidth == config.tabsWidth) {
				setStyle(handler.leftScrollButton, 1)(handler.rightScrollButton, config.SCROLLBUTTONALPHA);
			} else {
				setStyle(handler.leftScrollButton, 1)(handler.rightScrollButton, 1);
			}
			return this;
		},
		
		// 給滾動塊綁定事件
		bindScrollButtonEvents : function() {
			var handler            = _this.handler,
				scrollButtonEvents = handler.scrollButtonEvents;
			
			for (var p in scrollButtonEvents) {
				Ly.addEvent(p, scrollButtonEvents[p], handler.leftScrollButton);
				Ly.addEvent(p, scrollButtonEvents[p], handler.rightScrollButton);
			}
		},
		
		// 移除滾動塊已綁定的事件
		removeScrollButtonEvents : function() {
			var handler            = _this.handler,
				scrollButtonEvents = handler.scrollButtonEvents;
			
			for (var p in scrollButtonEvents) {
				Ly.removeEvent(handler.leftScrollButton, p, scrollButtonEvents[p]);
				Ly.removeEvent(handler.rightScrollButton, p, scrollButtonEvents[p]);
			}
		},
		
		/**
		 * 給標籤綁定事件
		 * @param {Object} tab 標籤對象，包含標籤節點，關閉按鈕，左右圓角對象，相關配置信息
		 */
		bindTabEvents : function(tab /* Object */) {
			var handler           = _this.handler,
				config            = _this.config,
				item              = tab.item,
				publicEvents      = config.events,
				privateEvents     = item.events,
				systemEvents      = handler.systemEvents,
				closeButtonEvents = handler.closeButtonEvents;
			
			for (var p in systemEvents) {
				Ly.addEvent(p, systemEvents[p], tab.tab);
			}
			
			for (p in closeButtonEvents) {
				Ly.addEvent(p, closeButtonEvents[p], tab.closeButton);
			}
			
			// 綁定公共事件
			for (p in publicEvents) {
				Ly.addEvent(p, publicEvents[p], tab.tab);
			}
			
			// 綁定私有事件
			for (p in privateEvents) {
				Ly.addEvent(p, privateEvents[p], tab.tab);
			}
			
			return this;
		},
		
		/**
		 * 清除綁定到標籤的所有事件
		 * @param {Object} tab 要清除事件的標籤
		 */
		removeEvents : function(tab /* Object */) {
			var handler           = _this.handler,
				config            = _this.config,
				item              = tab.item,
				publicEvents      = config.events,
				privateEvents     = item.events,
				systemEvents      = handler.systemEvents,
				closeButtonEvents = handler.closeButtonEvents;
			
			for (var p in systemEvents) {
				Ly.removeEvent(tab.tab, p, systemEvents[p]);
			}
			
			for (p in closeButtonEvents) {
				Ly.removeEvent(tab.closeButton, p, closeButtonEvents[p]);
			}
			
			// 綁定公共事件
			for (p in publicEvents) {
				Ly.removeEvent(tab.tab, p, publicEvents[p]);
			}
			
			// 綁定私有事件
			for (p in privateEvents) {
				Ly.removeEvent(tab.tab, p, privateEvents[p]);
			}
			
			return this;
		},
		
		// 清理緩存的標籤配置信息
		clearCache : function() {
			var handler = _this.handler;
			
			for (var i = handler.cache.length - 1; i > -1; --i) {
				handler.cache[i].closeButtonHandler = null;
				
				handler.cache[i].events = null;
				handler.cache.splice(i, 1);
			}
			
			delete handler.cache;
			
			return this;
		},
		
		/**
		 * 显示/隐藏标签栏的滚动按钮
		 * @param {Boolean} flag true为显示，false为隐藏
		 */
		toggleScrollButtons : function(flag /* Boolean */) {
			var handler            = _this.handler,
				width              = handler.tabsBar.clientWidth,
				scrollButtonsWidth = _this.config.SCROLLBUTTONWIDTH * 2;
			
			if (flag) {
				handler.leftScrollButton.style.display  = 'block';
				handler.rightScrollButton.style.display = 'block';
				handler.tabsBlock.style.width           = (width - scrollButtonsWidth) + 'px';
			} else {
				handler.leftScrollButton.style.display  = 'none';
				handler.rightScrollButton.style.display = 'none';
				handler.tabsBlock.style.width           = width + 'px';
			}
			
			return this;
		},
		
		/**
		 * 滑动标签栏
		 * @param {Number} direction 方向，大於零向左移動，小於零向右移動
		 * @param {Number} speed 移動速度，省略則為默認速度
		 */
		slidingTabsBar : function(direction /* Number */, speed /* Number */) {
			var handler    = _this.handler,
				config     = _this.config,
				tabsBlock  = handler.tabsBlock,
				tabsWidth  = this.getTabsWidth(), //config.tabsWidth,
				speed      = typeof speed == 'undefined' ? config.scrollParams.speed : speed,
				left,
				width;
			
			if (direction - 0 > 0) {
				left = Math.ceil(tabsBlock.scrollLeft + speed);
				
				if (tabsBlock.clientWidth + left > config.tabsWidth) {
					left = config.tabsWidth - tabsBlock.clientWidth;
				}
			} else {
				left = tabsBlock.scrollLeft - speed;
				left = left < 0 ? 0 : left;
			}
			
			tabsBlock.scrollLeft = left;
			
			this.updateScrollButtonStyle();
			return this;
		},
		
		/**
		 * 切换标签
		 * @param {Object} tab 要切换到的标签对象
		 */
		toggle : function(tab /* Object */) {
			var handler = _this.handler,
				config  = _this.config,
				tabs    = handler.tabs,
				nodes   = null,
				tabInfo = null;
			
			config.tabsWidth = this.getTabsWidth();
			if (handler.activedTab) {
				nodes = handler.activedTab.childNodes;
				for (var i = 0, len = nodes.length; i < len; ++i) {
					nodes[i].className = nodes[i].className.replace(' ly-rrtabpanel-' + nodes[i].getAttribute('role').toLowerCase() + '-active', '');
				}
				this.getTabInfo(handler.activedTab).workarea.style.left = '-5000px';
			}
			
			nodes = tab.childNodes;
			tabInfo = this.getTabInfo(tab);
			for (i = 0, len = nodes.length; i < len; ++i) {
				if (nodes[i].className.indexOf('-active') > -1) { continue; }
				nodes[i].className += ' ly-rrtabpanel-' + nodes[i].getAttribute('role').toLowerCase() + '-active';
			}
			tabInfo.workarea.style.left = 0;
			handler.activedTab = tab;
			
			if (tabInfo.item.reload || tabInfo.workarea.src.indexOf('Ly1.0a/resources/blank.html') > -1) {
				tabInfo.workarea.src = tabInfo.item.loadPage;
			}
			
			this.sliding(tab);
			return this;
		},
		
		sliding : function(tab /* Object */) {
			var handler      = _this.handler,
				config       = _this.config,
				scrollParams = config.scrollParams,
				method       = _this.method;
			
			setTimeout(function() {
				var width = method.getTabsWidth(tab);
				
				if (width < handler.tabsBlock.scrollLeft) {
					method.slidingTabsBar(-1, (handler.tabsBlock.scrollLeft - width) / 2 * 0.1);
					setTimeout(arguments.callee, scrollParams.delay);
				} else {
					width = method.getTabsWidth(tab, true);
					
					if (width > handler.tabsBlock.scrollLeft + handler.tabsBlock.clientWidth) {
						method.slidingTabsBar(1, (width - handler.tabsBlock.scrollLeft - handler.tabsBlock.clientWidth) / 2 * 0.1);
						setTimeout(arguments.callee, scrollParams.delay);
					}
				}
			}, scrollParams.delay);
		},
		
		/**
		 * 關閉指定的標籤
		 * @param {Object} tab 標籤對象，不包含相關信息。
		 */
		closeTab : function(tab /* Object */) {
			var handler = _this.handler,
				config  = _this.config,
				tabs    = handler.tabs,
				tabInfo = this.getTabInfo(tab),
				close   = true;
			
			if (tabInfo.item.closeButtonHandler && typeof tabInfo.item.closeButtonHandler == 'function') {
				close = !!tabInfo.item.closeButtonHandler.call(tabInfo.tab);
			}
			
			if (close && tabs.length > 1) {
				this.removeEvents(tabInfo);
				
				tabInfo.tabNode.removeChild(tabInfo.closeButton);
				tabInfo.tab.removeChild(tabInfo.tabLeft);
				tabInfo.tab.removeChild(tabInfo.tabNode);
				tabInfo.tab.removeChild(tabInfo.tabRight);
				
				handler.tabsContainer.removeChild(tabInfo.tab);
				handler.workarea.removeChild(tabInfo.workarea);
				
				tabInfo.tab = tabInfo.tabNode = tabInfo.closeButton = tabInfo.tabLeft = tabInfo.tabRight = tabInfo.workarea = null;
				
				var events = tabs[tabInfo.tmpIndex].item.events;
				
				for (var p in events) { events[p] = null; }
				
				tabs[tabInfo.tmpIndex].closeButtonHandler = null;
				tabs[tabInfo.tmpIndex] = null;
				tabs.splice(tabInfo.tmpIndex, 1);
				
				// 切换选中标签
				if (handler.activedTab === tab) {
					if (tabInfo.tmpIndex == 0 || tabs.length == 1) {
						this.toggle(handler.activedTab = tabs[0].tab);
					} else {
						this.toggle(handler.activedTab = tabs[tabInfo.tmpIndex - 1].tab);
					}
				}
				
				this.updateTabsView().slidingTabsBar(1, 0);
			}
			
			return this;
		},
		
		// 清理所有的iframe数据
		clear : function() {
			var tabs = _this.handler.tabs;
			
			for (var i = tabs.length - 1; i > -1; --i) {
				tabs[i].tab = tabs[i].tabNode = tabs[i].closeButton = tabs[i].tabLeft = tabs[i].tabRight = null;
				tabs[i].workarea.contentWindow.document.write("");
				tabs[i].workarea.contentWindow.document.clear();
			}
			Ly.isIE && setTimeout(CollectGarbage, 1);
		}
	};
};

Ly.RRTabPanel.prototype = {
	version : '1.0a',
	/**
	 * 添加一個新標籤，此方法不用調用render進行渲染，但使用此方法前一定要先調用了render方法。
	 * @param {Object} item 標籤配置信息
	 * item = {
		 title              : '標題',                 // 標籤的標題
		 width              : 0,                     // 標籤寬度，若設置為零，則自適應長度
		 loadPage           : 'a.html',              // 該標籤所要載入的頁面
		 preload            : false,                 // 此標籤是否要預載入，即創建完標籤就直接載入而不是激活后載入，默認false
		 reload             : false,                 // 此標籤是否每次激活都重新載入，默認false
		 defaultTab         : false,                 // 此標籤是否為默認標籤，即被自動激活的標籤，若沒有指定則默認第一個載入的標籤，默認false
		 closeButton        : false,                 // 是否顯示關閉按鈕，默認false
		 closeButtonHandler : function() {},         // 當標籤被關閉時所要處理的自定義事件。
		 events             : {}                     // 自定義事件
	 }
	 */
	add : function(item /* Object */) {
		this.method.createTab(this.method.formattingData(item)).updateTabsView();
		return this;
	},
	/**
	 * 綁定數據
	 * @param {Array} data item陣列，配置項參見add方法中的配置項。
	 */
	bind : function(data /* Array */) {
		if (data.constructor !== Array) {
			data = [];
			alert('bind方法的配置信息不正確！');
		}
		
		for (var i = 0, len = data.length; i < len; ++i) {
			this.handler.cache.push(this.method.formattingData(data[i]));
		}
		return this;
	},
	// 渲染
	render : function() {
		var _this = this;
		
		this.method.createFrame().setPanelSize().loadTabs();
		
		Ly.addEvent('onresize', function() {
			_this.method.setPanelSize().updateTabsView();
		}, window);
		
		Ly.addEvent('onbeforeunload', function() {
			_this.method.clear();
		}, window);
		
		return this;
	},
	/**
	 * 关闭标签
	 * @param {Object} tab 要关闭的标签
	 */
	close : function(tab /* Object */) {
		this.method.closeTab(tab);
		return this;
	},
	/**
	 * 切换标签
	 * @param {Object} tab 要切换到的标签
	 */
	toggle : function(tab /* Object */) {
		this.method.toggle(tab);
		return this;
	},
	/**
	 * 滑動到指定的標籤
	 * @param {Object} tab 目標標籤
	 */
	sliding : function(tab /* Object */) {
		this.method.sliding(tab);
		return this;
	},
	/**
	 * 获取标签信息
	 * @param {Object} tab 标签对象，省略則返回所有的標籤信息陣列
	 * @return {Object|Array} 當返回tab信息時。結構如下：
	  {
		  tab : '標籤容器',
		  tabNode : '標籤標題區域',
		  closeButton : '關閉按鈕',
		  tabLeft : '標籤左邊的圓角',
		  tabRight : '標籤右邊的圓角',
		  workarea : '工作區引用，即iframe引用',
		  item : '創建標籤時傳入的配置信息'
	  }
	  若為Array則返回以上信息的陣列
	 */
	getTabInfo : function(tab /* Object */) {
		if (tab) {
			return this.method.getTabInfo(tab);
		} else {
			return this.handler.tabs;
		}
	},
	/**
	 * 獲取當前激活的標籤對象
	 * @return {Object} tab
	 */
	getCurrentTab : function() {
		return this.handler.activedTab;
	}
};